// utils/useWebSocket.js
import { ref, onUnmounted } from 'vue';
import { getToken } from '@/utils/auth';
import env from '@/env'

export function useWebSocket(url) {
  const messages = ref([]); // 存储收到的消息
  const isConnected = ref(false);
  const error = ref(null);
  
  // 设置消息回调
  let messageCallback = null;

  const connect = () => {
    return new Promise((resolve, reject) => {
      console.log('正在连接WebSocket...');
      
      // 先清理所有监听器
      try {
        uni.closeSocket({
          success: () => console.log('已关闭之前的连接')
        });
        
        uni.offSocketOpen();
        uni.offSocketMessage();
        uni.offSocketError();
        uni.offSocketClose();
      } catch (err) {
        console.log('清理之前的连接:', err);
      }
      
      // 先注册事件处理器
      uni.onSocketOpen(function(res) {
        console.log('WebSocket 已连接', res);
        isConnected.value = true;
        resolve(res);
      });
      
      uni.onSocketError(function(err) {
        console.error('WebSocket 连接错误:', err);
        isConnected.value = false;
        error.value = err;
        reject(err);
      });
      
      uni.onSocketMessage(function(res) {
        console.log('收到消息:', res.data);
        
        try {
          if (typeof res.data === 'string') {
            // 字符串消息直接添加到messages中
            messages.value.push(res.data);
            // 如果设置了回调，则调用回调
            if (messageCallback) {
              messageCallback(res.data);
            }
          } else {
            // 尝试解析JSON
            const data = typeof res.data === 'object' ? res.data : JSON.parse(res.data);
            messages.value.push(data);
            // 如果设置了回调，则调用回调
            if (messageCallback) {
              messageCallback(data);
            }
          }
        } catch (error) {
          console.error('处理消息异常:', error);
          messages.value.push(res.data);
          if (messageCallback) {
            messageCallback(res.data);
          }
        }
      });
      
      uni.onSocketClose(function(res) {
        console.log('WebSocket 已关闭:', res);
        isConnected.value = false;
      });
      
      // 拼接WebSocket URL
      const fullUrl = url + '?Authorization=Bearer ' + encodeURIComponent(getToken()) + '&clientid=' + encodeURIComponent(env.VITE_APP_CLIENT_ID);
      console.log('连接WebSocket URL:', fullUrl);
      
      // 发起连接
      uni.connectSocket({
        url: fullUrl,
        success: function() {
          console.log('WebSocket连接请求已发送，等待连接成功回调...');
        },
        fail: function(err) {
          console.error('WebSocket连接请求发送失败:', err);
          reject(err);
        }
      });
      
      // 10秒超时
      setTimeout(() => {
        if (!isConnected.value) {
          console.error('WebSocket连接超时');
          reject(new Error('WebSocket连接超时'));
        }
      }, 10000);
    });
  };
  
  // 发送消息
  const sendMessage = (data) => {
    return new Promise((resolve, reject) => {
      if (!isConnected.value) {
        reject(new Error('WebSocket未连接'));
        return;
      }
      
      const message = typeof data === 'string' ? data : JSON.stringify(data);
      console.log('发送WebSocket消息:', message);
      
      uni.sendSocketMessage({
        data: message,
        success: () => {
          console.log('WebSocket消息发送成功');
          resolve();
        },
        fail: (err) => {
          console.error('WebSocket消息发送失败:', err);
          reject(err);
        }
      });
    });
  };
  
  // 关闭连接
  const close = () => {
    console.log('关闭WebSocket连接');
    uni.closeSocket();
    isConnected.value = false;
  };
  
  // 注册消息处理回调
  const onMessage = (callback) => {
    messageCallback = callback;
  };
  
  // 组件卸载时关闭连接
  onUnmounted(() => {
    close();
  });
  
  return {
    messages,
    isConnected,
    error,
    connect,
    sendMessage,
    close,
    onMessage
  };
}